/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Attributes.h.zapt

#pragma once

#include <app/ConcreteAttributePath.h>
#include <app/data-model/DecodableList.h>
#include <app/data-model/List.h>
#include <app/data-model/Nullable.h>
#include <app/util/basic-types.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Attributes.h>
#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/PowerSource/AttributeIds.h>
#include <clusters/PowerSource/ClusterId.h>
#include <clusters/PowerSource/Enums.h>
#include <clusters/PowerSource/Structs.h>

namespace chip
{
namespace app
{
	namespace Clusters
	{
		namespace PowerSource
		{
			namespace Attributes
			{

				namespace Status
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::PowerSourceStatusEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::PowerSourceStatusEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::PowerSourceStatusEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Status::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Status
				namespace Order
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Order::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace Order
				namespace Description
				{
					struct TypeInfo {
						using Type = chip::CharSpan;
						using DecodableType = chip::CharSpan;
						using DecodableArgType = chip::CharSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::Description::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 60; }
					};
				} // namespace Description
				namespace WiredAssessedInputVoltage
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredAssessedInputVoltage::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredAssessedInputVoltage
				namespace WiredAssessedInputFrequency
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint16_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint16_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredAssessedInputFrequency::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredAssessedInputFrequency
				namespace WiredCurrentType
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::WiredCurrentTypeEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredCurrentType::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredCurrentType
				namespace WiredAssessedCurrent
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredAssessedCurrent::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredAssessedCurrent
				namespace WiredNominalVoltage
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredNominalVoltage::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredNominalVoltage
				namespace WiredMaximumCurrent
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredMaximumCurrent::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredMaximumCurrent
				namespace WiredPresent
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::WiredPresent::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace WiredPresent
				namespace ActiveWiredFaults
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<
							const chip::app::Clusters::PowerSource::WiredFaultEnum>;
						using DecodableType = chip::app::DataModel::DecodableList<
							chip::app::Clusters::PowerSource::WiredFaultEnum>;
						using DecodableArgType = const chip::app::DataModel::DecodableList<
							chip::app::Clusters::PowerSource::WiredFaultEnum> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ActiveWiredFaults::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ActiveWiredFaults
				namespace BatVoltage
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatVoltage::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatVoltage
				namespace BatPercentRemaining
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint8_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint8_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatPercentRemaining::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatPercentRemaining
				namespace BatTimeRemaining
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatTimeRemaining::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatTimeRemaining
				namespace BatChargeLevel
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::BatChargeLevelEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::BatChargeLevelEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::BatChargeLevelEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatChargeLevel::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatChargeLevel
				namespace BatReplacementNeeded
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatReplacementNeeded::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatReplacementNeeded
				namespace BatReplaceability
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::BatReplaceabilityEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::BatReplaceabilityEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::BatReplaceabilityEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatReplaceability::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatReplaceability
				namespace BatPresent
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatPresent::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatPresent
				namespace ActiveBatFaults
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<
							const chip::app::Clusters::PowerSource::BatFaultEnum>;
						using DecodableType = chip::app::DataModel::DecodableList<
							chip::app::Clusters::PowerSource::BatFaultEnum>;
						using DecodableArgType = const chip::app::DataModel::DecodableList<
							chip::app::Clusters::PowerSource::BatFaultEnum> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ActiveBatFaults::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ActiveBatFaults
				namespace BatReplacementDescription
				{
					struct TypeInfo {
						using Type = chip::CharSpan;
						using DecodableType = chip::CharSpan;
						using DecodableArgType = chip::CharSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatReplacementDescription::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 60; }
					};
				} // namespace BatReplacementDescription
				namespace BatCommonDesignation
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::BatCommonDesignationEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::BatCommonDesignationEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::BatCommonDesignationEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatCommonDesignation::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatCommonDesignation
				namespace BatANSIDesignation
				{
					struct TypeInfo {
						using Type = chip::CharSpan;
						using DecodableType = chip::CharSpan;
						using DecodableArgType = chip::CharSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatANSIDesignation::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 20; }
					};
				} // namespace BatANSIDesignation
				namespace BatIECDesignation
				{
					struct TypeInfo {
						using Type = chip::CharSpan;
						using DecodableType = chip::CharSpan;
						using DecodableArgType = chip::CharSpan;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatIECDesignation::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
						static constexpr size_t MaxLength() { return 20; }
					};
				} // namespace BatIECDesignation
				namespace BatApprovedChemistry
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::BatApprovedChemistryEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatApprovedChemistry::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatApprovedChemistry
				namespace BatCapacity
				{
					struct TypeInfo {
						using Type = uint32_t;
						using DecodableType = uint32_t;
						using DecodableArgType = uint32_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatCapacity::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatCapacity
				namespace BatQuantity
				{
					struct TypeInfo {
						using Type = uint8_t;
						using DecodableType = uint8_t;
						using DecodableArgType = uint8_t;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatQuantity::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatQuantity
				namespace BatChargeState
				{
					struct TypeInfo {
						using Type = chip::app::Clusters::PowerSource::BatChargeStateEnum;
						using DecodableType =
							chip::app::Clusters::PowerSource::BatChargeStateEnum;
						using DecodableArgType =
							chip::app::Clusters::PowerSource::BatChargeStateEnum;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatChargeState::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatChargeState
				namespace BatTimeToFullCharge
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatTimeToFullCharge::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatTimeToFullCharge
				namespace BatFunctionalWhileCharging
				{
					struct TypeInfo {
						using Type = bool;
						using DecodableType = bool;
						using DecodableArgType = bool;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatFunctionalWhileCharging::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatFunctionalWhileCharging
				namespace BatChargingCurrent
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableType = chip::app::DataModel::Nullable<uint32_t>;
						using DecodableArgType =
							const chip::app::DataModel::Nullable<uint32_t> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::BatChargingCurrent::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace BatChargingCurrent
				namespace ActiveBatChargeFaults
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<
							const chip::app::Clusters::PowerSource::BatChargeFaultEnum>;
						using DecodableType = chip::app::DataModel::DecodableList<
							chip::app::Clusters::PowerSource::BatChargeFaultEnum>;
						using DecodableArgType = const chip::app::DataModel::DecodableList<
							chip::app::Clusters::PowerSource::BatChargeFaultEnum> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::ActiveBatChargeFaults::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace ActiveBatChargeFaults
				namespace EndpointList
				{
					struct TypeInfo {
						using Type = chip::app::DataModel::List<const chip::EndpointId>;
						using DecodableType =
							chip::app::DataModel::DecodableList<chip::EndpointId>;
						using DecodableArgType =
							const chip::app::DataModel::DecodableList<chip::EndpointId> &;

						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
						static constexpr AttributeId GetAttributeId()
						{
							return Attributes::EndpointList::Id;
						}
						static constexpr bool MustUseTimedWrite() { return false; }
					};
				} // namespace EndpointList
				namespace GeneratedCommandList
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::GeneratedCommandList::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
					};
				} // namespace GeneratedCommandList
				namespace AcceptedCommandList
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::AcceptedCommandList::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
					};
				} // namespace AcceptedCommandList
				namespace AttributeList
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::AttributeList::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
					};
				} // namespace AttributeList
				namespace FeatureMap
				{
					struct TypeInfo : public Clusters::Globals::Attributes::FeatureMap::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
					};
				} // namespace FeatureMap
				namespace ClusterRevision
				{
					struct TypeInfo
						: public Clusters::Globals::Attributes::ClusterRevision::TypeInfo {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}
					};
				} // namespace ClusterRevision

				struct TypeInfo {
					struct DecodableType {
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::PowerSource::Id;
						}

						CHIP_ERROR Decode(TLV::TLVReader &reader,
								  const ConcreteAttributePath &path);

						Attributes::Status::TypeInfo::DecodableType status = static_cast<
							chip::app::Clusters::PowerSource::PowerSourceStatusEnum>(0);
						Attributes::Order::TypeInfo::DecodableType order =
							static_cast<uint8_t>(0);
						Attributes::Description::TypeInfo::DecodableType description;
						Attributes::WiredAssessedInputVoltage::TypeInfo::DecodableType
							wiredAssessedInputVoltage;
						Attributes::WiredAssessedInputFrequency::TypeInfo::DecodableType
							wiredAssessedInputFrequency;
						Attributes::WiredCurrentType::TypeInfo::DecodableType wiredCurrentType =
							static_cast<
								chip::app::Clusters::PowerSource::WiredCurrentTypeEnum>(
								0);
						Attributes::WiredAssessedCurrent::TypeInfo::DecodableType
							wiredAssessedCurrent;
						Attributes::WiredNominalVoltage::TypeInfo::DecodableType
							wiredNominalVoltage = static_cast<uint32_t>(0);
						Attributes::WiredMaximumCurrent::TypeInfo::DecodableType
							wiredMaximumCurrent = static_cast<uint32_t>(0);
						Attributes::WiredPresent::TypeInfo::DecodableType wiredPresent =
							static_cast<bool>(0);
						Attributes::ActiveWiredFaults::TypeInfo::DecodableType activeWiredFaults;
						Attributes::BatVoltage::TypeInfo::DecodableType batVoltage;
						Attributes::BatPercentRemaining::TypeInfo::DecodableType
							batPercentRemaining;
						Attributes::BatTimeRemaining::TypeInfo::DecodableType batTimeRemaining;
						Attributes::BatChargeLevel::TypeInfo::DecodableType batChargeLevel =
							static_cast<chip::app::Clusters::PowerSource::BatChargeLevelEnum>(
								0);
						Attributes::BatReplacementNeeded::TypeInfo::DecodableType
							batReplacementNeeded = static_cast<bool>(0);
						Attributes::BatReplaceability::TypeInfo::DecodableType
							batReplaceability = static_cast<
								chip::app::Clusters::PowerSource::BatReplaceabilityEnum>(
								0);
						Attributes::BatPresent::TypeInfo::DecodableType batPresent =
							static_cast<bool>(0);
						Attributes::ActiveBatFaults::TypeInfo::DecodableType activeBatFaults;
						Attributes::BatReplacementDescription::TypeInfo::DecodableType
							batReplacementDescription;
						Attributes::BatCommonDesignation::TypeInfo::DecodableType
							batCommonDesignation =
								static_cast<chip::app::Clusters::PowerSource::
										    BatCommonDesignationEnum>(0);
						Attributes::BatANSIDesignation::TypeInfo::DecodableType
							batANSIDesignation;
						Attributes::BatIECDesignation::TypeInfo::DecodableType batIECDesignation;
						Attributes::BatApprovedChemistry::TypeInfo::DecodableType
							batApprovedChemistry =
								static_cast<chip::app::Clusters::PowerSource::
										    BatApprovedChemistryEnum>(0);
						Attributes::BatCapacity::TypeInfo::DecodableType batCapacity =
							static_cast<uint32_t>(0);
						Attributes::BatQuantity::TypeInfo::DecodableType batQuantity =
							static_cast<uint8_t>(0);
						Attributes::BatChargeState::TypeInfo::DecodableType batChargeState =
							static_cast<chip::app::Clusters::PowerSource::BatChargeStateEnum>(
								0);
						Attributes::BatTimeToFullCharge::TypeInfo::DecodableType
							batTimeToFullCharge;
						Attributes::BatFunctionalWhileCharging::TypeInfo::DecodableType
							batFunctionalWhileCharging = static_cast<bool>(0);
						Attributes::BatChargingCurrent::TypeInfo::DecodableType
							batChargingCurrent;
						Attributes::ActiveBatChargeFaults::TypeInfo::DecodableType
							activeBatChargeFaults;
						Attributes::EndpointList::TypeInfo::DecodableType endpointList;
						Attributes::GeneratedCommandList::TypeInfo::DecodableType
							generatedCommandList;
						Attributes::AcceptedCommandList::TypeInfo::DecodableType
							acceptedCommandList;
						Attributes::AttributeList::TypeInfo::DecodableType attributeList;
						Attributes::FeatureMap::TypeInfo::DecodableType featureMap =
							static_cast<uint32_t>(0);
						Attributes::ClusterRevision::TypeInfo::DecodableType clusterRevision =
							static_cast<uint16_t>(0);
					};
				};
			} // namespace Attributes
		} // namespace PowerSource
	} // namespace Clusters
} // namespace app
} // namespace chip
